#pragma once

#include "util.hh"
#include "conf.hh"

namespace cloud
{

namespace util
{
struct path : easyfs::path
{
    path(const std::string& s) : easyfs::path(s) {}

    static std::string fpath2bpath(const std::string& pre, const std::string& s)
    {
        return (easyfs::path(pre) / s).string();
    }
    static std::string bpath2fpath(const std::string& s)
    {
        return easyfs::path(s).remove_top_directory().string();
    }
    static bool exists(const std::string& s)
    {
        return easyfs::exists(s);
    }
    static bool isfile(const std::string& s)
    {
        return easyfs::is_file(s);
    }
    static bool isdir(const std::string& s)
    {
        return easyfs::is_directory(s);
    }
};
}

struct backup_info
{
    time_t mtime;
    size_t fsize;

    std::string fpath;
    std::string bpath;

    backup_info() = default;

    backup_info(const util::json& js) { parserfrom(js); }

    backup_info(const std::string& bp) : bpath(bp)
    {
        fpath = util::path::bpath2fpath(bp);

        util::file f(bpath);

        if (!f.exists())
            easylog::error("file {} is not existed", bpath);

        fsize = f.size();
        mtime = f.mtime();
    }

    time_t modify_time()
    {
        return util::file(bpath).mtime();
    }

    std::string content()
    {
        return util::file(bpath).read();
    }

    util::json parser_to_json() const
    {
        util::json js;
        js.set("fsize", fsize);
        js.set("mtime", mtime);
        js.set("fpath", fpath);
        js.set("bpath", bpath);
        return js;
    }

    void parserfrom(const util::json& js)
    {
        fsize = js.get<size_t>("fsize");
        mtime = js.get<time_t>("mtime");
        fpath = js.get<std::string>("fpath");
        bpath = js.get<std::string>("bpath");
    }
};

}
